/**
 * 自动组件加载服务
 * 扫描库目录并自动注册所有组件，无需手动维护映射
 */

import { defineAsyncComponent, markRaw } from 'vue';
import componentManager from './ComponentManagerService';

// 组件类别定义
const COMPONENT_CATEGORIES = ['basic', 'business', 'custom'];

/**
 * 自动组件加载器类
 * 实现组件自动发现、注册和类型映射
 */
export class AutoComponentLoader {
  constructor() {
    this.componentMap = new Map();
    this.componentCategories = [];
    this.componentPaths = {};
    this.componentAliases = {};
    this.initialized = false;
  }

  /**
   * 初始化并加载所有组件
   * @returns {Promise<void>}
   */
  async initialize() {
    if (this.initialized) return {
      componentMap: this.componentMap,
      componentCategories: this.componentCategories,
      componentPaths: this.componentPaths,
      componentAliases: this.componentAliases
    };
    
    console.log('[AutoComponentLoader] 初始化自动组件加载器');
    
    // 初始化组件分类
    this.initializeCategories();
    
    // 扫描并加载组件配置
    await this.scanComponentConfigs();
    
    console.log('[AutoComponentLoader] 组件扫描完成，找到', this.componentMap.size, '个组件');
    console.log('[AutoComponentLoader] 别名映射：', Object.keys(this.componentAliases).length, '个映射');
    
    this.initialized = true;
    
    return {
      componentMap: this.componentMap,
      componentCategories: this.componentCategories,
      componentPaths: this.componentPaths,
      componentAliases: this.componentAliases
    };
  }

  /**
   * 初始化组件分类结构
   */
  initializeCategories() {
    this.componentCategories = COMPONENT_CATEGORIES.map(key => ({
      title: this.getCategoryTitle(key),
      key: key,
      components: []
    }));
  }

  /**
   * 根据类别键获取类别标题
   * @param {string} key 类别键
   * @returns {string} 类别标题
   */
  getCategoryTitle(key) {
    const titles = {
      'basic': '基础组件',
      'business': '业务组件',
      'custom': '自定义组件'
    };
    return titles[key] || key;
  }

  /**
   * 扫描并加载所有组件配置
   * @returns {Promise<void>}
   */
  async scanComponentConfigs() {
    // 为每个类别扫描组件
    for (const category of COMPONENT_CATEGORIES) {
      await this.scanCategoryComponents(category);
    }
  }

  /**
   * 扫描特定类别的组件
   * @param {string} category 组件类别
   * @returns {Promise<void>}
   */
  async scanCategoryComponents(category) {
    // 动态导入指定类别下的所有组件配置
    const configModules = import.meta.glob('../components/library/*/*/config.js', { eager: true });
    const categoryIndex = COMPONENT_CATEGORIES.indexOf(category);
    
    if (categoryIndex === -1) {
      console.warn(`[AutoComponentLoader] 未知组件类别: ${category}`);
      return;
    }
    
    // 处理找到的配置文件
    for (const path in configModules) {
      // 检查配置是否属于当前处理的类别
      if (!path.includes(`/${category}/`)) continue;
      
      const config = configModules[path].default;
      const pathParts = path.split('/');
      const componentName = pathParts[pathParts.length - 2]; // 获取组件名称
      
      // 添加到组件映射
      this.componentMap.set(componentName, config);
      
      // 构建组件路径映射
      const componentPath = `${category}/${componentName}`;
      this.componentPaths[`ew-${componentName}`] = componentPath;
      
      // 创建别名映射
      this.generateAliasesForComponent(componentName);
      
      // 添加到分类中
      this.componentCategories[categoryIndex].components.push({
        text: config.text,
        type: config.type || componentName,
        icon: config.icon || 'icon-zidingyimokuai',
        vanIcon: config.vanIcon,
        name: componentName
      });
      
      console.log(`[AutoComponentLoader] 加载组件配置: ${componentName} (${category})`);
    }
  }

  /**
   * 为组件生成所有可能的别名
   * @param {string} componentName 组件名
   */
  generateAliasesForComponent(componentName) {
    // 标准命名（带ew-前缀）
    const standardName = `ew-${componentName}`;
    
    // 所有可能的别名
    const aliases = [
      componentName,                   // 基本名称
      `el-${componentName}`,           // Element Plus 风格
      standardName,                    // 标准名称 (ew-前缀)
      `${componentName}-component`     // 带后缀的名称
    ];
    
    // 将所有别名添加到映射表
    aliases.forEach(alias => {
      this.componentAliases[alias] = standardName;
    });
  }

  /**
   * 标准化组件类型
   * @param {string} componentType 原始组件类型
   * @returns {string} 标准化后的组件类型
   */
  normalizeComponentType(componentType) {
    if (!componentType) return 'div';
    
    // 直接从别名映射获取标准类型
    if (this.componentAliases[componentType]) {
      return this.componentAliases[componentType];
    }
    
    // 处理前缀组件
    if (componentType.startsWith('ew-')) {
      const baseType = componentType.substring(3);
      // 尝试在映射表中查找基础类型
      if (this.componentPaths[baseType]) {
        return baseType;
      }
    }
    
    // 处理自定义路径组件
    if (componentType.includes('/')) {
      return componentType; // 已经是路径格式
    }
    
    // 返回原始类型
    return componentType;
  }

  /**
   * 解析组件路径
   * @param {string} componentType 组件类型
   * @returns {string|null} 组件路径或null
   */
  resolveComponentPath(componentType) {
    // 先标准化组件类型
    const normalizedType = this.normalizeComponentType(componentType);
    
    // 从路径映射中查找
    if (this.componentPaths[normalizedType]) {
      return this.componentPaths[normalizedType];
    }
    
    // 处理自定义路径组件
    if (normalizedType.includes('/')) {
      return normalizedType; // 已经是路径格式
    }
    
    // 未找到对应路径
    console.warn(`[AutoComponentLoader] 无法解析组件路径: ${componentType} (标准类型: ${normalizedType})`);
    return null;
  }

  /**
   * 加载组件预览处理模块
   * @param {string} componentType 组件类型
   * @returns {Promise<Object|null>} 组件预览处理模块或null
   */
  async loadComponentPreview(componentType) {
    try {
      // 确保已初始化
      if (!this.initialized) {
        await this.initialize();
      }
      
      // 解析组件路径
      const componentPath = this.resolveComponentPath(componentType);
      if (!componentPath) return null;
      
      // 动态导入预览处理模块
      const module = await import(/* @vite-ignore */ `../components/library/${componentPath}/preview.js`);
      return module.default || module;
    } catch (error) {
      console.warn(`[AutoComponentLoader] 无法加载组件预览处理模块: ${componentType}`, error);
      return null;
    }
  }

  /**
   * 加载组件导出处理模块
   * @param {string} componentType 组件类型
   * @returns {Promise<Object|null>} 组件导出处理模块或null
   */
  async loadComponentExport(componentType) {
    try {
      // 确保已初始化
      if (!this.initialized) {
        await this.initialize();
      }
      
      // 解析组件路径
      const componentPath = this.resolveComponentPath(componentType);
      if (!componentPath) return null;
      
      // 动态导入导出处理模块
      const module = await import(/* @vite-ignore */ `../components/library/${componentPath}/export.js`);
      return module.default || module;
    } catch (error) {
      console.warn(`[AutoComponentLoader] 无法加载组件导出处理模块: ${componentType}`, error);
      return null;
    }
  }

  /**
   * 加载组件配置模块
   * @param {string} componentType 组件类型
   * @returns {Promise<Object|null>} 组件配置模块或null
   */
  async loadComponentConfig(componentType) {
    try {
      // 确保已初始化
      if (!this.initialized) {
        await this.initialize();
      }
      
      // 解析组件路径
      const componentPath = this.resolveComponentPath(componentType);
      if (!componentPath) return null;
      
      // 动态导入配置模块
      const module = await import(/* @vite-ignore */ `../components/library/${componentPath}/config.js`);
      return module.default || module;
    } catch (error) {
      console.warn(`[AutoComponentLoader] 无法加载组件配置模块: ${componentType}`, error);
      return null;
    }
  }

  /**
   * 检查组件是否支持预览
   * @param {string} componentType 组件类型
   * @returns {Promise<boolean>} 是否支持预览
   */
  async supportsPreview(componentType) {
    const previewModule = await this.loadComponentPreview(componentType);
    return previewModule !== null;
  }

  /**
   * 检查组件是否支持导出
   * @param {string} componentType 组件类型
   * @returns {Promise<boolean>} 是否支持导出
   */
  async supportsExport(componentType) {
    const exportModule = await this.loadComponentExport(componentType);
    return exportModule !== null;
  }

  /**
   * 刷新组件映射表
   * @returns {Promise<boolean>} 是否成功刷新
   */
  async refreshComponentMapping() {
    this.initialized = false;
    this.componentMap.clear();
    this.componentPaths = {};
    this.componentAliases = {};
    
    try {
      await this.initialize();
      return true;
    } catch (error) {
      console.error('[AutoComponentLoader] 刷新组件映射失败:', error);
      return false;
    }
  }

  /**
   * 注册所有组件到 Vue 应用
   * @param {object} app Vue 应用实例
   */
  registerComponents(app) {
    if (!app) {
      console.error('[AutoComponentLoader] 无法注册组件，应用实例为空');
      return;
    }
    
    // 动态导入组件和编辑器
    const components = import.meta.glob('../components/library/*/*/index.vue');
    const editors = import.meta.glob('../components/library/*/*/editor.vue');
    
    // 注册主组件
    for (const path in components) {
      const pathParts = path.split('/');
      const name = pathParts[pathParts.length - 2];
      const componentName = 'ew-' + name;
      
      // 检查组件是否已注册，避免重复注册
      if (!app._context.components[componentName]) {
        const asyncComponent = defineAsyncComponent(components[path]);
        app.component(componentName, asyncComponent);
        
        // 同时注册到组件管理器
        componentManager.registerComponent(componentName, asyncComponent);
        
        console.log(`[AutoComponentLoader] 注册组件: ${componentName}`);
      }
    }
    
    // 注册编辑器组件
    for (const path in editors) {
      const pathParts = path.split('/');
      const name = pathParts[pathParts.length - 2] + 'style';
      
      // 检查组件是否已注册，避免重复注册
      if (!app._context.components[name]) {
        const asyncComponent = defineAsyncComponent(editors[path]);
        app.component(name, asyncComponent);
        console.log(`[AutoComponentLoader] 注册编辑器: ${name}`);
      }
    }
  }
}

// 创建单例
const autoComponentLoader = new AutoComponentLoader();

export default autoComponentLoader; 